package com.xtt._02_guava;

import com.google.common.collect.Lists;
import com.google.common.collect.Ordering;
import org.junit.Test;

import java.util.ArrayList;
import java.util.List;

/**
 * @Author xtt.
 * @Description: guava 比较器
 * @Date:Create in 2017/9/19 0019 下午 23:06
 * @Modify By:
 */
public class OrderingTest {
    /*
    常见的静态方法：

　　natural()：使用Comparable类型的自然顺序， 例如：整数从小到大，字符串是按字典顺序;
　　usingToString() ：使用toString()返回的字符串按字典顺序进行排序；
　　arbitrary() ：返回一个所有对象的任意顺序， 即compare(a, b) == 0 就是 a == b (identity equality)。 本身的排序是没有任何含义， 但是在VM的生命周期是一个常量。
    * 操作方法：

　　reverse(): 返回与当前Ordering相反的排序:
　　nullsFirst(): 返回一个将null放在non-null元素之前的Ordering，其他的和原始的Ordering一样；
　　nullsLast()：返回一个将null放在non-null元素之后的Ordering，其他的和原始的Ordering一样；
　　compound(Comparator)：返回一个使用Comparator的Ordering，Comparator作为第二排序元素，例如对bug列表进行排序，先根据bug的级别，再根据优先级进行排序；
　　lexicographical()：返回一个按照字典元素迭代的Ordering；
　　onResultOf(Function)：将function应用在各个元素上之后, 在使用原始ordering进行排序；
　　greatestOf(Iterable iterable, int k)：返回指定的第k个可迭代的最大的元素，按照这个从最大到最小的顺序。是不稳定的。
　　leastOf(Iterable<E> iterable,int k)：返回指定的第k个可迭代的最小的元素，按照这个从最小到最大的顺序。是不稳定的。
　　isOrdered(Iterable)：是否有序，Iterable不能少于2个元素。
　　isStrictlyOrdered(Iterable)：是否严格有序。请注意，Iterable不能少于两个元素。
　　sortedCopy(Iterable)：返回指定的元素作为一个列表的排序副本。*/

    @Test
    public void testStatic() {
        ArrayList<String> list = Lists.newArrayList();
        list.add("a");
        list.add("s");
        list.add("d");
        list.add("f");
        list.add("g");
        list.add("h");
        list.add("j");
        Ordering<Comparable> natural = Ordering.natural();//使用Comparable类型的自然顺序， 例如：整数从小到大，字符串是按字典顺序;
        List<String> strings = natural.sortedCopy(list);
        System.out.println(strings);

        Ordering<Object> objectOrdering = Ordering.usingToString();//使用toString()返回的字符串按字典顺序进行排序；
        List<String> strings2 = objectOrdering.sortedCopy(strings);
        System.out.println(strings2);

        Ordering<Object> arbitrary = Ordering.arbitrary();//返回一个所有对象的任意顺序，但每次执行结果是一样的
        List<String> strings1 = arbitrary.sortedCopy(list);
        System.out.println(strings1);//[f, j, g, s, a, h, d]

    }

    @Test
    public void testOrdering() {
        ArrayList<String> list = Lists.newArrayList();
        list.add("a");
        list.add("s");
        list.add("d");
        list.add("f");
        list.add("g");
        list.add("h");
        list.add("j");

        Ordering<Comparable> natural = Ordering.natural();
        System.out.println("natural:"+ natural.sortedCopy(list));
        System.out.println("leastOf list:"+natural.leastOf(list, 3));
        System.out.println("greatestOf:"+natural.greatestOf(list, 3));
        System.out.println("reverse list :"+ natural.reverse().sortedCopy(list));
        System.out.println("isOrdered list :"+ natural.isOrdered(list));
        System.out.println("isOrdered list :"+ natural.reverse().isOrdered(list));
        list.add(null);
        System.out.println(" add null list:"+list);
        System.out.println("nullsFirst list :"+ natural.nullsFirst().sortedCopy(list));
        System.out.println("nullsLast list :"+ natural.nullsLast().sortedCopy(list));
        /*  natural:[a, d, f, g, h, j, s]
            leastOf list:[a, d, f]
            greatestOf:[s, j, h]
            reverse list :[s, j, h, g, f, d, a]
            isOrdered list :false
            isOrdered list :false
             add null list:[a, s, d, f, g, h, j, null]
            nullsFirst list :[null, a, d, f, g, h, j, s]
            nullsLast list :[a, d, f, g, h, j, s, null]
            */
    }
}
